/**
 * 权限验证工具函数
 * 提供组件内使用的权限检查方法
 */
import { useUserStore } from '@/stores/user'

/**
 * 检查单个权限
 * @param permission 权限标识
 * @returns 是否有权限
 */
export function checkPermi(permission: string): boolean {
  const userStore = useUserStore()
  if (userStore.isSuperAdmin) return true
  return userStore.hasPermission(permission)
}

/**
 * 检查多个权限（任一）
 * @param permissions 权限数组
 * @returns 是否有权限
 */
export function checkPermiOr(permissions: string[]): boolean {
  const userStore = useUserStore()
  if (userStore.isSuperAdmin) return true
  return userStore.hasAnyPermission(permissions)
}

/**
 * 检查多个权限（全部）
 * @param permissions 权限数组
 * @returns 是否有权限
 */
export function checkPermiAnd(permissions: string[]): boolean {
  const userStore = useUserStore()
  if (userStore.isSuperAdmin) return true
  return userStore.hasAllPermissions(permissions)
}

/**
 * 检查单个角色
 * @param role 角色标识
 * @returns 是否有角色
 */
export function checkRole(role: string): boolean {
  const userStore = useUserStore()
  return userStore.hasRole(role)
}

/**
 * 检查多个角色（任一）
 * @param roles 角色数组
 * @returns 是否有角色
 */
export function checkRoleOr(roles: string[]): boolean {
  const userStore = useUserStore()
  return roles.some(r => userStore.hasRole(r))
}

/**
 * 检查多个角色（全部）
 * @param roles 角色数组
 * @returns 是否有角色
 */
export function checkRoleAnd(roles: string[]): boolean {
  const userStore = useUserStore()
  return roles.every(r => userStore.hasRole(r))
}

/**
 * 综合权限检查
 * @param config 权限配置
 * @returns 是否有权限
 */
export function checkAuth(config: {
  permissions?: string[]
  roles?: string[]
  requireAll?: boolean
}): boolean {
  const { permissions, roles, requireAll = false } = config
  const userStore = useUserStore()
  if (userStore.isSuperAdmin) return true
  let ok = true
  if (permissions && permissions.length) {
    ok = requireAll ? userStore.hasAllPermissions(permissions) : userStore.hasAnyPermission(permissions)
  }
  if (!ok) return false
  if (roles && roles.length) {
    ok = requireAll ? roles.every(r => userStore.hasRole(r)) : roles.some(r => userStore.hasRole(r))
  }
  return ok
}

/**
 * 检查是否为超级管理员
 * @returns 是否为超级管理员
 */
export function isSuperAdmin(): boolean {
  const userStore = useUserStore()
  return userStore.isSuperAdmin
}

/**
 * 获取当前用户权限列表
 * @returns 权限列表
 */
export function getCurrentUserPermissions(): string[] {
  const userStore = useUserStore()
  return userStore.userPermissions
}

/**
 * 获取当前用户角色列表
 * @returns 角色列表
 */
export function getCurrentUserRoles(): string[] {
  const userStore = useUserStore()
  return userStore.userRoles
}

/**
 * 权限验证装饰器（用于方法装饰）
 * @param permissions 需要的权限
 * @returns 装饰器函数
 */
export function requirePermissions(permissions: string | string[]) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value
    
    descriptor.value = function (...args: any[]) {
      const hasPermission = Array.isArray(permissions) 
        ? checkPermiOr(permissions) 
        : checkPermi(permissions)
        
      if (!hasPermission) {
        console.warn(`权限不足: ${JSON.stringify(permissions)}`)
        return Promise.reject(new Error('权限不足'))
      }
      
      return originalMethod.apply(this, args)
    }
    
    return descriptor
  }
}

/**
 * 角色验证装饰器（用于方法装饰）
 * @param roles 需要的角色
 * @returns 装饰器函数
 */
export function requireRoles(roles: string | string[]) {
  return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const originalMethod = descriptor.value
    
    descriptor.value = function (...args: any[]) {
      const hasRole = Array.isArray(roles) 
        ? checkRoleOr(roles) 
        : checkRole(roles)
        
      if (!hasRole) {
        console.warn(`角色不足: ${JSON.stringify(roles)}`)
        return Promise.reject(new Error('角色不足'))
      }
      
      return originalMethod.apply(this, args)
    }
    
    return descriptor
  }
}

/**
 * 权限错误处理
 */
export class PermissionError extends Error {
  constructor(message: string, public permissions?: string[], public roles?: string[]) {
    super(message)
    this.name = 'PermissionError'
  }
}

/**
 * 创建权限错误
 * @param message 错误消息
 * @param permissions 缺少的权限
 * @param roles 缺少的角色
 * @returns 权限错误对象
 */
export function createPermissionError(
  message: string, 
  permissions?: string[], 
  roles?: string[]
): PermissionError {
  return new PermissionError(message, permissions, roles)
}

/**
 * 权限检查结果
 */
export interface PermissionCheckResult {
  hasPermission: boolean
  message?: string
  missingPermissions?: string[]
  missingRoles?: string[]
}

/**
 * 详细权限检查
 * @param config 权限配置
 * @returns 检查结果
 */
export function checkPermissionDetails(config: {
  permissions?: string[]
  roles?: string[]
  requireAll?: boolean
}): PermissionCheckResult {
  const { permissions, roles, requireAll = false } = config
  const userStore = useUserStore()
  
  // 超级管理员拥有所有权限
  if (userStore.isSuperAdmin) {
    return { hasPermission: true }
  }
  
  const result: PermissionCheckResult = {
    hasPermission: true,
    missingPermissions: [],
    missingRoles: []
  }
  
  // 检查权限
  if (permissions && permissions.length > 0) {
    const userPermissions = userStore.userPermissions
    const missingPerms = permissions.filter(p => !userPermissions.includes(p))
    
    if (requireAll) {
      // 需要所有权限
      if (missingPerms.length > 0) {
        result.hasPermission = false
        result.missingPermissions = missingPerms
      }
    } else {
      // 需要任一权限
      if (missingPerms.length === permissions.length) {
        result.hasPermission = false
        result.missingPermissions = missingPerms
      }
    }
  }
  
  // 检查角色
  if (roles && roles.length > 0) {
    const userRoles = userStore.userRoles
    const missingRoles = roles.filter(r => !userRoles.includes(r))
    
    if (requireAll) {
      // 需要所有角色
      if (missingRoles.length > 0) {
        result.hasPermission = false
        result.missingRoles = missingRoles
      }
    } else {
      // 需要任一角色
      if (missingRoles.length === roles.length) {
        result.hasPermission = false
        result.missingRoles = missingRoles
      }
    }
  }
  
  // 生成错误信息
  if (!result.hasPermission) {
    const messages: string[] = []
    if (result.missingPermissions?.length) {
      messages.push(`缺少权限: ${result.missingPermissions.join(', ')}`)
    }
    if (result.missingRoles?.length) {
      messages.push(`缺少角色: ${result.missingRoles.join(', ')}`)
    }
    result.message = messages.join('; ')
  }
  
  return result
}
